home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 98 / Skunkware 98.iso / src / interp / perl5.005.tar.gz / perl5.005.tar / perl5.005 / win32 / GenCAPI.pl < prev    next >
Text File  |  1998-07-21  |  38KB  |  1,556 lines
  1.  
  2. # creates a C API file from proto.h
  3. # takes one argument, the path to lib/CORE directory.
  4. # creates 2 files: "perlCAPI.cpp" and "perlCAPI.h".
  5.  
  6. my $hdrfile = "$ARGV[0]\\perlCAPI.h";
  7. my $infile = '..\\proto.h';
  8. my $embedfile = '..\\embed.h';
  9. my $separateObj = 0;
  10.  
  11. my %skip_list;
  12. my %embed;
  13.  
  14. sub readembed(\%$) {
  15.     my ($syms, $file) = @_;
  16.     my ($line, @words);
  17.     %$syms = ();
  18.     local (*FILE, $_);
  19.     open(FILE, "< $file")
  20.     or die "$0: Can't open $file: $!\n";
  21.     while ($line = <FILE>) {
  22.     chop($line);
  23.     if ($line =~ /^#define\s+\w+/) {
  24.         $line =~ s/^#define\s+//;
  25.         @words = split ' ', $line;
  26. #        print "$words[0]\t$words[1]\n";
  27.         $$syms{$words[0]} = $words[1];
  28.     }
  29.     }
  30.     close(FILE);
  31. }
  32.  
  33. readembed %embed, $embedfile;
  34.  
  35. sub skip_these {
  36.     my $list = shift;
  37.     foreach my $symbol (@$list) {
  38.     $skip_list{$symbol} = 1;
  39.     }
  40. }
  41.  
  42. skip_these [qw(
  43. cando
  44. cast_ulong
  45. my_chsize
  46. condpair_magic
  47. deb
  48. deb_growlevel
  49. debprofdump
  50. debop
  51. debstack
  52. debstackptrs
  53. dump_fds
  54. dump_mstats
  55. fprintf
  56. find_threadsv
  57. magic_mutexfree
  58. my_memcmp
  59. my_memset
  60. my_pclose
  61. my_popen
  62. my_swap
  63. my_htonl
  64. my_ntohl
  65. new_struct_thread
  66. same_dirent
  67. unlnk
  68. unlock_condpair
  69. safexmalloc
  70. safexcalloc
  71. safexrealloc
  72. safexfree
  73. Perl_GetVars
  74. malloced_size
  75. )];
  76.  
  77.  
  78.  
  79. if (!open(INFILE, "<$infile")) {
  80.     print "open of $infile failed: $!\n";
  81.     return 1;
  82. }
  83.  
  84. if (!open(OUTFILE, ">perlCAPI.cpp")) {
  85.     print "open of perlCAPI.cpp failed: $!\n";
  86.     return 1;
  87. }
  88.  
  89. print OUTFILE <<ENDCODE;
  90. #include "EXTERN.h"
  91. #include "perl.h"
  92. #include "XSUB.h"
  93.   
  94. #define DESTRUCTORFUNC (void (*)(void*))
  95.   
  96. ENDCODE
  97.  
  98. print OUTFILE "#ifdef SetCPerlObj_defined\n" unless ($separateObj == 0);
  99.  
  100. print OUTFILE <<ENDCODE;
  101. extern "C" void SetCPerlObj(CPerlObj* pP)
  102. {
  103.     pPerl = pP;
  104. }
  105.   
  106. ENDCODE
  107.  
  108. print OUTFILE "#endif\n" unless ($separateObj == 0); 
  109.  
  110. while () {
  111.     last unless defined ($_ = <INFILE>);
  112.     if (/^VIRTUAL\s/) {
  113.         while (!/;$/) {
  114.             chomp;
  115.             $_ .= <INFILE>;
  116.         }
  117.         $_ =~ s/^VIRTUAL\s*//;
  118.         $_ =~ s/\s*__attribute__.*$/;/;
  119.         if ( /(.*)\s([A-z_]*[0-9A-z_]+\s)_\(\((.*)\)\);/ ||
  120.              /(.*)\*([A-z_]*[0-9A-z_]+\s)_\(\((.*)\)\);/ ) {
  121.             $type = $1;
  122.             $name = $2;
  123.             $args = $3;
  124.  
  125.             $name =~ s/\s*$//;
  126.             $type =~ s/\s*$//;
  127.         next if (defined $skip_list{$name});
  128.  
  129.         if($args eq "ARGSproto") {
  130.         $args = "void";
  131.         }
  132.  
  133.             $return = ($type eq "void" or $type eq "Free_t") ? "\t" : "\treturn";
  134.  
  135.         if(defined $embed{$name}) {
  136.         $funcName = $embed{$name};
  137.         } else {
  138.         $funcName = $name;
  139.         }
  140.  
  141.             @args = split(',', $args);
  142.             if ($args[$#args] =~ /\s*\.\.\.\s*/) {
  143.                 if(($name eq "croak") or ($name eq "deb") or ($name eq "die")
  144.                 or ($name eq "form") or ($name eq "warn")) {
  145.                     print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
  146.                     $args[0] =~ /(\w+)\W*$/; 
  147.                     $arg = $1;
  148.                     print OUTFILE <<ENDCODE;
  149.  
  150. #undef $name
  151. extern "C" $type $funcName ($args)
  152. {
  153.     char *pstr;
  154.     char *pmsg;
  155.     va_list args;
  156.     va_start(args, $arg);
  157.     pmsg = pPerl->Perl_mess($arg, &args);
  158.     New(0, pstr, strlen(pmsg)+1, char);
  159.     strcpy(pstr, pmsg);
  160. $return pPerl->Perl_$name(pstr);
  161.     va_end(args);
  162. }
  163. ENDCODE
  164.                     print OUTFILE "#endif\n" unless ($separateObj == 0);
  165.                 }
  166.                 elsif($name eq "newSVpvf") {
  167.                     print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
  168.                     $args[0] =~ /(\w+)\W*$/; 
  169.                     $arg = $1;
  170.                     print OUTFILE <<ENDCODE;
  171.  
  172. #undef $name
  173. extern "C" $type $funcName ($args)
  174. {
  175.     SV *sv;
  176.     va_list args;
  177.     va_start(args, $arg);
  178.     sv = pPerl->Perl_newSV(0);
  179.     pPerl->Perl_sv_vcatpvfn(sv, $arg, strlen($arg), &args, NULL, 0, NULL);
  180.     va_end(args);
  181.     return sv;
  182. }
  183. ENDCODE
  184.                     print OUTFILE "#endif\n" unless ($separateObj == 0);
  185.                 }
  186.                 elsif($name eq "sv_catpvf") {
  187.                     print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
  188.                     $args[0] =~ /(\w+)\W*$/; 
  189.                     $arg0 = $1;
  190.                     $args[1] =~ /(\w+)\W*$/; 
  191.                     $arg1 = $1;
  192.                     print OUTFILE <<ENDCODE;
  193.  
  194. #undef $name
  195. extern "C" $type $funcName ($args)
  196. {
  197.     va_list args;
  198.     va_start(args, $arg1);
  199.     pPerl->Perl_sv_vcatpvfn($arg0, $arg1, strlen($arg1), &args, NULL, 0, NULL);
  200.     va_end(args);
  201. }
  202. ENDCODE
  203.                     print OUTFILE "#endif\n" unless ($separateObj == 0);
  204.                 }
  205.                 elsif($name eq "sv_setpvf") {
  206.                     print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
  207.                     $args[0] =~ /(\w+)\W*$/; 
  208.                     $arg0 = $1;
  209.                     $args[1] =~ /(\w+)\W*$/; 
  210.                     $arg1 = $1;
  211.                     print OUTFILE <<ENDCODE;
  212.  
  213. #undef $name
  214. extern "C" $type $funcName ($args)
  215. {
  216.     va_list args;
  217.     va_start(args, $arg1);
  218.     pPerl->Perl_sv_vsetpvfn($arg0, $arg1, strlen($arg1), &args, NULL, 0, NULL);
  219.     va_end(args);
  220. }
  221. ENDCODE
  222.                     print OUTFILE "#endif\n" unless ($separateObj == 0);
  223.                 }
  224.                 elsif($name eq "fprintf") {
  225.                     print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
  226.                     $args[0] =~ /(\w+)\W*$/; 
  227.                     $arg0 = $1;
  228.                     $args[1] =~ /(\w+)\W*$/; 
  229.                     $arg1 = $1;
  230.                     print OUTFILE <<ENDCODE;
  231.  
  232. #undef $name
  233. extern "C" $type $name ($args)
  234. {
  235.     int nRet;
  236.     va_list args;
  237.     va_start(args, $arg1);
  238.     nRet = PerlIO_vprintf($arg0, $arg1, args);
  239.     va_end(args);
  240.     return nRet;
  241. }
  242. ENDCODE
  243.                     print OUTFILE "#endif\n" unless ($separateObj == 0);
  244.                 } else {
  245.                     print "Warning: can't handle varargs function '$name'\n";
  246.                 }
  247.                 next;
  248.             }
  249.  
  250.         # newXS special case
  251.         if ($name eq "newXS") {
  252.         next;
  253.         }
  254.             
  255.             print OUTFILE "\n#ifdef $name" . "defined" unless ($separateObj == 0);
  256.  
  257.         # handle specical case for save_destructor
  258.         if ($name eq "save_destructor") {
  259.         next;
  260.         }
  261.         # handle specical case for sighandler
  262.         if ($name eq "sighandler") {
  263.         next;
  264.         }
  265.         # handle special case for sv_grow
  266.         if ($name eq "sv_grow" and $args eq "SV* sv, unsigned long newlen") {
  267.         next;
  268.         }
  269.         # handle special case for newSV
  270.         if ($name eq "newSV" and $args eq "I32 x, STRLEN len") {
  271.         next;
  272.         }
  273.         # handle special case for perl_parse
  274.         if ($name eq "perl_parse") {
  275.         print OUTFILE <<ENDCODE;
  276.  
  277. #undef $name
  278. extern "C" $type $name ($args)
  279. {
  280.     return pPerl->perl_parse(xsinit, argc, argv, env);
  281. }
  282. ENDCODE
  283.                 print OUTFILE "#endif\n" unless ($separateObj == 0);
  284.         next;
  285.         }
  286.         # handle special case for perl_atexit
  287.         if ($name eq "perl_atexit") {
  288.         print OUTFILE <<ENDCODE;
  289.  
  290. #undef $name
  291. extern "C" $type $name ($args)
  292. {
  293.     pPerl->perl_atexit(fn, ptr);
  294. }
  295. ENDCODE
  296.                 print OUTFILE "#endif\n" unless ($separateObj == 0);
  297.         next;
  298.         }
  299.  
  300.  
  301.         if($name eq "byterun" and $args eq "struct bytestream bs") {
  302.         next;
  303.         }
  304.  
  305.             # foo(void);
  306.             if ($args eq "void") {
  307.                 print OUTFILE <<ENDCODE;
  308.  
  309. #undef $name
  310. extern "C" $type $funcName ()
  311. {
  312. $return pPerl->$funcName();
  313. }
  314.  
  315. ENDCODE
  316.                 print OUTFILE "#endif\n" unless ($separateObj == 0);
  317.                 next;
  318.             }
  319.  
  320.             # foo(char *s, const int bar);
  321.             print OUTFILE <<ENDCODE;
  322.  
  323. #undef $name
  324. extern "C" $type $funcName ($args)
  325. {
  326. ENDCODE
  327.         print OUTFILE "$return pPerl->$funcName";
  328.             $doneone = 0;
  329.             foreach $arg (@args) {
  330.                 if ($arg =~ /(\w+)\W*$/) {
  331.                     if ($doneone) {
  332.                         print OUTFILE ", $1";
  333.                     }
  334.                     else {
  335.                         print OUTFILE "($1";
  336.                         $doneone++;
  337.                     }
  338.                 }
  339.             }
  340.             print OUTFILE ");\n}\n";
  341.             print OUTFILE "#endif\n" unless ($separateObj == 0);
  342.         }
  343.         else {
  344.             print "failed to match $_";
  345.         }
  346.     }
  347. }
  348.  
  349. close INFILE;
  350.  
  351. %skip_list = ();
  352.  
  353. skip_these [qw(
  354. strchop
  355. filemode
  356. lastfd
  357. oldname
  358. curinterp
  359. Argv
  360. Cmd
  361. sortcop
  362. sortstash
  363. firstgv
  364. secondgv
  365. sortstack
  366. signalstack
  367. mystrk
  368. dumplvl
  369. oldlastpm
  370. gensym
  371. preambled
  372. preambleav
  373. Ilaststatval
  374. Ilaststype
  375. mess_sv
  376. ors
  377. opsave
  378. eval_mutex
  379. orslen
  380. ofmt
  381. modcount
  382. generation
  383. DBcv
  384. archpat_auto
  385. sortcxix
  386. lastgotoprobe
  387. regdummy
  388. regcomp_parse
  389. regxend
  390. regcode
  391. regnaughty
  392. regsawback
  393. regprecomp
  394. regnpar
  395. regsize
  396. regflags
  397. regseen
  398. seen_zerolen
  399. regcomp_rx
  400. extralen
  401. colorset
  402. colors
  403. reginput
  404. regbol
  405. regeol
  406. regstartp
  407. regendp
  408. reglastparen
  409. regtill
  410. regprev
  411. reg_start_tmp
  412. reg_start_tmpl
  413. regdata
  414. bostr
  415. reg_flags
  416. reg_eval_set
  417. regnarrate
  418. regprogram
  419. regindent
  420. regcc
  421. in_clean_objs
  422. in_clean_all
  423. linestart
  424. pending_ident
  425. statusvalue_vms
  426. sublex_info
  427. thrsv
  428. threadnum
  429. PL_piMem
  430. PL_piENV
  431. PL_piStdIO
  432. PL_piLIO
  433. PL_piDir
  434. PL_piSock
  435. PL_piProc
  436. cshname
  437. threadsv_names
  438. thread
  439. nthreads
  440. thr_key
  441. threads_mutex
  442. malloc_mutex
  443. svref_mutex
  444. sv_mutex
  445. nthreads_cond
  446. eval_cond
  447. cryptseen
  448. cshlen
  449. )];
  450.  
  451. sub readvars(\%$$) {
  452.     my ($syms, $file, $pre) = @_;
  453.     %$syms = ();
  454.     local (*FILE, $_);
  455.     open(FILE, "< $file")
  456.     or die "$0: Can't open $file: $!\n";
  457.     while (<FILE>) {
  458.     s/[ \t]*#.*//;        # Delete comments.
  459.     if (/PERLVARI?C?\($pre(\w+),\s*([^,)]+)/) {
  460.         $$syms{$1} = $2;
  461.     }
  462.     }
  463.     close(FILE);
  464. }
  465.  
  466. my %intrp;
  467. my %thread;
  468. my %globvar;
  469.  
  470. readvars %intrp,  '..\intrpvar.h','I';
  471. readvars %thread, '..\thrdvar.h','T';
  472. readvars %globvar, '..\perlvars.h','G';
  473.  
  474. open(HDRFILE, ">$hdrfile") or die "$0: Can't open $hdrfile: $!\n";
  475. print HDRFILE <<ENDCODE;
  476. void SetCPerlObj(void* pP);
  477. CV* Perl_newXS(char* name, void (*subaddr)(CV* cv), char* filename);
  478.  
  479. ENDCODE
  480.  
  481. sub DoVariable($$) {
  482.     my $name = shift;
  483.     my $type = shift;
  484.  
  485.     return if (defined $skip_list{$name});
  486.     return if ($type eq 'struct perl_thread *');
  487.  
  488.     print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
  489.     print OUTFILE <<ENDCODE;
  490. #undef PL_$name
  491. extern "C" $type * _PL_$name ()
  492. {
  493.     return (($type *)&pPerl->PL_$name);
  494. }
  495.  
  496. ENDCODE
  497.  
  498.     print OUTFILE "#endif\n" unless ($separateObj == 0);
  499.  
  500.     print HDRFILE <<ENDCODE;
  501.  
  502. #undef PL_$name
  503. $type * _PL_$name ();
  504. #define PL_$name (*_PL_$name())
  505.  
  506. ENDCODE
  507.  
  508. }
  509.  
  510. foreach $key (keys %intrp) {
  511.     DoVariable ($key, $intrp{$key});
  512. }
  513.  
  514. foreach $key (keys %thread) {
  515.     DoVariable ($key, $thread{$key});
  516. }
  517.  
  518. foreach $key (keys %globvar) {
  519.     DoVariable ($key, $globvar{$key});
  520. }
  521.  
  522. print OUTFILE <<EOCODE;
  523.  
  524.  
  525. extern "C" {
  526.  
  527.  
  528. char **    _Perl_op_desc(void)
  529. {
  530.     return pPerl->Perl_get_op_descs();
  531. }
  532.  
  533. char **    _Perl_op_name(void)
  534. {
  535.     return pPerl->Perl_get_op_names();
  536. }
  537.  
  538. char *    _Perl_no_modify(void)
  539. {
  540.     return pPerl->Perl_get_no_modify();
  541. }
  542.  
  543. U32 *    _Perl_opargs(void)
  544. {
  545.     return pPerl->Perl_get_opargs();
  546. }
  547.  
  548. void xs_handler(CV* cv, CPerlObj* p)
  549. {
  550.     void(*func)(CV*);
  551.     SV* sv;
  552.     MAGIC* m = pPerl->Perl_mg_find((SV*)cv, '~');
  553.     if(m != NULL)
  554.     {
  555.     sv = m->mg_obj;
  556.     if(SvIOK(sv))
  557.     {
  558.         func = (void(*)(CV*))SvIVX(sv);
  559.     }
  560.     else
  561.     {
  562.         func = (void(*)(CV*))pPerl->Perl_sv_2iv(sv);
  563.     }
  564.     func(cv);
  565.     }
  566. }
  567.  
  568. CV* Perl_newXS(char* name, void (*subaddr)(CV* cv), char* filename)
  569. {
  570.     CV* cv = pPerl->Perl_newXS(name, xs_handler, filename);
  571.     pPerl->Perl_sv_magic((SV*)cv, pPerl->Perl_sv_2mortal(pPerl->Perl_newSViv((IV)subaddr)), '~', "CAPI", 4);
  572.     return cv;
  573. }
  574.  
  575.  
  576. void Perl_deb(const char pat, ...)
  577. {
  578. }
  579.  
  580. #undef PL_piMem
  581. #undef PL_piENV
  582. #undef PL_piStdIO
  583. #undef PL_piLIO
  584. #undef PL_piDir
  585. #undef PL_piSock
  586. #undef PL_piProc
  587.  
  588. int *        _win32_errno(void)
  589. {
  590.     return &pPerl->ErrorNo();
  591. }
  592.  
  593. FILE*        _win32_stdin(void)
  594. {
  595.     return (FILE*)pPerl->PL_piStdIO->Stdin();
  596. }
  597.  
  598. FILE*        _win32_stdout(void)
  599. {
  600.     return (FILE*)pPerl->PL_piStdIO->Stdout();
  601. }
  602.  
  603. FILE*        _win32_stderr(void)
  604. {
  605.     return (FILE*)pPerl->PL_piStdIO->Stderr();
  606. }
  607.  
  608. int          _win32_ferror(FILE *fp)
  609. {
  610.     return pPerl->PL_piStdIO->Error((PerlIO*)fp, ErrorNo());
  611. }
  612.  
  613. int          _win32_feof(FILE *fp)
  614. {
  615.     return pPerl->PL_piStdIO->Eof((PerlIO*)fp, ErrorNo());
  616. }
  617.  
  618. char*         _win32_strerror(int e)
  619. {
  620.     return strerror(e);
  621. }
  622.  
  623. void         _win32_perror(const char *str)
  624. {
  625.     perror(str);
  626. }
  627.  
  628. int          _win32_vfprintf(FILE *pf, const char *format, va_list arg)
  629. {
  630.     return pPerl->PL_piStdIO->Vprintf((PerlIO*)pf, ErrorNo(), format, arg);
  631. }
  632.  
  633. int          _win32_vprintf(const char *format, va_list arg)
  634. {
  635.     return pPerl->PL_piStdIO->Vprintf(pPerl->PL_piStdIO->Stdout(), ErrorNo(), format, arg);
  636. }
  637.  
  638. int          _win32_fprintf(FILE *pf, const char *format, ...)
  639. {
  640.     int ret;
  641.     va_list args;
  642.     va_start(args, format);
  643.     ret = _win32_vfprintf(pf, format, args);
  644.     va_end(args);
  645.     return ret;
  646. }
  647.  
  648. int          _win32_printf(const char *format, ...)
  649. {
  650.     int ret;
  651.     va_list args;
  652.     va_start(args, format);
  653.     ret = _win32_vprintf(format, args);
  654.     va_end(args);
  655.     return ret;
  656. }
  657.  
  658. size_t       _win32_fread(void *buf, size_t size, size_t count, FILE *pf)
  659. {
  660.     return pPerl->PL_piStdIO->Read((PerlIO*)pf, buf, (size*count), ErrorNo());
  661. }
  662.  
  663. size_t       _win32_fwrite(const void *buf, size_t size, size_t count, FILE *pf)
  664. {
  665.     return pPerl->PL_piStdIO->Write((PerlIO*)pf, buf, (size*count), ErrorNo());
  666. }
  667.  
  668. FILE*        _win32_fopen(const char *path, const char *mode)
  669. {
  670.     return (FILE*)pPerl->PL_piStdIO->Open(path, mode, ErrorNo());
  671. }
  672.  
  673. FILE*        _win32_fdopen(int fh, const char *mode)
  674. {
  675.     return (FILE*)pPerl->PL_piStdIO->Fdopen(fh, mode, ErrorNo());
  676. }
  677.  
  678. FILE*        _win32_freopen(const char *path, const char *mode, FILE *pf)
  679. {
  680.     return (FILE*)pPerl->PL_piStdIO->Reopen(path, mode, (PerlIO*)pf, ErrorNo());
  681. }
  682.  
  683. int          _win32_fclose(FILE *pf)
  684. {
  685.     return pPerl->PL_piStdIO->Close((PerlIO*)pf, ErrorNo());
  686. }
  687.  
  688. int          _win32_fputs(const char *s,FILE *pf)
  689. {
  690.     return pPerl->PL_piStdIO->Puts((PerlIO*)pf, s, ErrorNo());
  691. }
  692.  
  693. int          _win32_fputc(int c,FILE *pf)
  694. {
  695.     return pPerl->PL_piStdIO->Putc((PerlIO*)pf, c, ErrorNo());
  696. }
  697.  
  698. int          _win32_ungetc(int c,FILE *pf)
  699. {
  700.     return pPerl->PL_piStdIO->Ungetc((PerlIO*)pf, c, ErrorNo());
  701. }
  702.  
  703. int          _win32_getc(FILE *pf)
  704. {
  705.     return pPerl->PL_piStdIO->Getc((PerlIO*)pf, ErrorNo());
  706. }
  707.  
  708. int          _win32_fileno(FILE *pf)
  709. {
  710.     return pPerl->PL_piStdIO->Fileno((PerlIO*)pf, ErrorNo());
  711. }
  712.  
  713. void         _win32_clearerr(FILE *pf)
  714. {
  715.     pPerl->PL_piStdIO->Clearerr((PerlIO*)pf, ErrorNo());
  716. }
  717.  
  718. int          _win32_fflush(FILE *pf)
  719. {
  720.     return pPerl->PL_piStdIO->Flush((PerlIO*)pf, ErrorNo());
  721. }
  722.  
  723. long         _win32_ftell(FILE *pf)
  724. {
  725.     return pPerl->PL_piStdIO->Tell((PerlIO*)pf, ErrorNo());
  726. }
  727.  
  728. int          _win32_fseek(FILE *pf,long offset,int origin)
  729. {
  730.     return pPerl->PL_piStdIO->Seek((PerlIO*)pf, offset, origin, ErrorNo());
  731. }
  732.  
  733. int          _win32_fgetpos(FILE *pf,fpos_t *p)
  734. {
  735.     return pPerl->PL_piStdIO->Getpos((PerlIO*)pf, p, ErrorNo());
  736. }
  737.  
  738. int          _win32_fsetpos(FILE *pf,const fpos_t *p)
  739. {
  740.     return pPerl->PL_piStdIO->Setpos((PerlIO*)pf, p, ErrorNo());
  741. }
  742.  
  743. void         _win32_rewind(FILE *pf)
  744. {
  745.     pPerl->PL_piStdIO->Rewind((PerlIO*)pf, ErrorNo());
  746. }
  747.  
  748. FILE*        _win32_tmpfile(void)
  749. {
  750.     return (FILE*)pPerl->PL_piStdIO->Tmpfile(ErrorNo());
  751. }
  752.  
  753. void         _win32_setbuf(FILE *pf, char *buf)
  754. {
  755.     pPerl->PL_piStdIO->SetBuf((PerlIO*)pf, buf, ErrorNo());
  756. }
  757.  
  758. int          _win32_setvbuf(FILE *pf, char *buf, int type, size_t size)
  759. {
  760.     return pPerl->PL_piStdIO->SetVBuf((PerlIO*)pf, buf, type, size, ErrorNo());
  761. }
  762.  
  763. char*        _win32_fgets(char *s, int n, FILE *pf)
  764. {
  765.     return pPerl->PL_piStdIO->Gets((PerlIO*)pf, s, n, ErrorNo());
  766. }
  767.  
  768. char*        _win32_gets(char *s)
  769. {
  770.     return _win32_fgets(s, 80, (FILE*)pPerl->PL_piStdIO->Stdin());
  771. }
  772.  
  773. int          _win32_fgetc(FILE *pf)
  774. {
  775.     return pPerl->PL_piStdIO->Getc((PerlIO*)pf, ErrorNo());
  776. }
  777.  
  778. int          _win32_putc(int c, FILE *pf)
  779. {
  780.     return pPerl->PL_piStdIO->Putc((PerlIO*)pf, c, ErrorNo());
  781. }
  782.  
  783. int          _win32_puts(const char *s)
  784. {
  785.     return pPerl->PL_piStdIO->Puts(pPerl->PL_piStdIO->Stdout(), s, ErrorNo());
  786. }
  787.  
  788. int          _win32_getchar(void)
  789. {
  790.     return pPerl->PL_piStdIO->Getc(pPerl->PL_piStdIO->Stdin(), ErrorNo());
  791. }
  792.  
  793. int          _win32_putchar(int c)
  794. {
  795.     return pPerl->PL_piStdIO->Putc(pPerl->PL_piStdIO->Stdout(), c, ErrorNo());
  796. }
  797.  
  798. void*        _win32_malloc(size_t size)
  799. {
  800.     return pPerl->PL_piMem->Malloc(size);
  801. }
  802.  
  803. void*        _win32_calloc(size_t numitems, size_t size)
  804. {
  805.     return pPerl->PL_piMem->Malloc(numitems*size);
  806. }
  807.  
  808. void*        _win32_realloc(void *block, size_t size)
  809. {
  810.     return pPerl->PL_piMem->Realloc(block, size);
  811. }
  812.  
  813. void         _win32_free(void *block)
  814. {
  815.     pPerl->PL_piMem->Free(block);
  816. }
  817.  
  818. void         _win32_abort(void)
  819. {
  820.     pPerl->PL_piProc->Abort();
  821. }
  822.  
  823. int          _win32_pipe(int *phandles, unsigned int psize, int textmode)
  824. {
  825.     return pPerl->PL_piProc->Pipe(phandles);
  826. }
  827.  
  828. FILE*        _win32_popen(const char *command, const char *mode)
  829. {
  830.     return (FILE*)pPerl->PL_piProc->Popen(command, mode);
  831. }
  832.  
  833. int          _win32_pclose(FILE *pf)
  834. {
  835.     return pPerl->PL_piProc->Pclose((PerlIO*)pf);
  836. }
  837.  
  838. unsigned     _win32_sleep(unsigned int t)
  839. {
  840.     return pPerl->PL_piProc->Sleep(t);
  841. }
  842.  
  843. int    _win32_spawnvp(int mode, const char *cmdname, const char *const *argv)
  844. {
  845.     return pPerl->PL_piProc->Spawnvp(mode, cmdname, argv);
  846. }
  847.  
  848. int          _win32_mkdir(const char *dir, int mode)
  849. {
  850.     return pPerl->PL_piDir->Makedir(dir, mode, ErrorNo());
  851. }
  852.  
  853. int          _win32_rmdir(const char *dir)
  854. {
  855.     return pPerl->PL_piDir->Rmdir(dir, ErrorNo());
  856. }
  857.  
  858. int          _win32_chdir(const char *dir)
  859. {
  860.     return pPerl->PL_piDir->Chdir(dir, ErrorNo());
  861. }
  862.  
  863. #undef stat
  864. int          _win32_fstat(int fd,struct stat *sbufptr)
  865. {
  866.     return pPerl->PL_piLIO->FileStat(fd, sbufptr, ErrorNo());
  867. }
  868.  
  869. int          _win32_stat(const char *name,struct stat *sbufptr)
  870. {
  871.     return pPerl->PL_piLIO->NameStat(name, sbufptr, ErrorNo());
  872. }
  873.  
  874. int          _win32_rename(const char *oname, const char *newname)
  875. {
  876.     return pPerl->PL_piLIO->Rename(oname, newname, ErrorNo());
  877. }
  878.  
  879. int          _win32_setmode(int fd, int mode)
  880. {
  881.     return pPerl->PL_piLIO->Setmode(fd, mode, ErrorNo());
  882. }
  883.  
  884. long         _win32_lseek(int fd, long offset, int origin)
  885. {
  886.     return pPerl->PL_piLIO->Lseek(fd, offset, origin, ErrorNo());
  887. }
  888.  
  889. long         _win32_tell(int fd)
  890. {
  891.     return pPerl->PL_piStdIO->Tell((PerlIO*)fd, ErrorNo());
  892. }
  893.  
  894. int          _win32_dup(int fd)
  895. {
  896.     return pPerl->PL_piLIO->Dup(fd, ErrorNo());
  897. }
  898.  
  899. int          _win32_dup2(int h1, int h2)
  900. {
  901.     return pPerl->PL_piLIO->Dup2(h1, h2, ErrorNo());
  902. }
  903.  
  904. int          _win32_open(const char *path, int oflag,...)
  905. {
  906.     return pPerl->PL_piLIO->Open(path, oflag, ErrorNo());
  907. }
  908.  
  909. int          _win32_close(int fd)
  910. {
  911.     return pPerl->PL_piLIO->Close(fd, ErrorNo());
  912. }
  913.  
  914. int          _win32_read(int fd, void *buf, unsigned int cnt)
  915. {
  916.     return pPerl->PL_piLIO->Read(fd, buf, cnt, ErrorNo());
  917. }
  918.  
  919. int          _win32_write(int fd, const void *buf, unsigned int cnt)
  920. {
  921.     return pPerl->PL_piLIO->Write(fd, buf, cnt, ErrorNo());
  922. }
  923.  
  924. int          _win32_times(struct tms *timebuf)
  925. {
  926.     return pPerl->PL_piProc->Times(timebuf);
  927. }
  928.  
  929. int          _win32_ioctl(int i, unsigned int u, char *data)
  930. {
  931.     return pPerl->PL_piLIO->IOCtl(i, u, data, ErrorNo());
  932. }
  933.  
  934. int          _win32_utime(const char *f, struct utimbuf *t)
  935. {
  936.     return pPerl->PL_piLIO->Utime((char*)f, t, ErrorNo());
  937. }
  938.  
  939. char*   _win32_getenv(const char *name)
  940. {
  941.     return pPerl->PL_piENV->Getenv(name, ErrorNo());
  942. }
  943.  
  944. int          _win32_open_osfhandle(long handle, int flags)
  945. {
  946.     return pPerl->PL_piStdIO->OpenOSfhandle(handle, flags);
  947. }
  948.  
  949. long         _win32_get_osfhandle(int fd)
  950. {
  951.     return pPerl->PL_piStdIO->GetOSfhandle(fd);
  952. }
  953.  
  954. u_long _win32_htonl (u_long hostlong)
  955. {
  956.     return pPerl->PL_piSock->Htonl(hostlong);
  957. }
  958.  
  959. u_short _win32_htons (u_short hostshort)
  960. {
  961.     return pPerl->PL_piSock->Htons(hostshort);
  962. }
  963.  
  964. u_long _win32_ntohl (u_long netlong)
  965. {
  966.     return pPerl->PL_piSock->Ntohl(netlong);
  967. }
  968.  
  969. u_short _win32_ntohs (u_short netshort)
  970. {
  971.     return pPerl->PL_piSock->Ntohs(netshort);
  972. }
  973.  
  974. unsigned long _win32_inet_addr (const char * cp)
  975. {
  976.     return pPerl->PL_piSock->InetAddr(cp, ErrorNo());
  977. }
  978.  
  979. char * _win32_inet_ntoa (struct in_addr in)
  980. {
  981.     return pPerl->PL_piSock->InetNtoa(in, ErrorNo());
  982. }
  983.  
  984. SOCKET _win32_socket (int af, int type, int protocol)
  985. {
  986.     return pPerl->PL_piSock->Socket(af, type, protocol, ErrorNo());
  987. }
  988.  
  989. int _win32_bind (SOCKET s, const struct sockaddr *addr, int namelen)
  990. {
  991.     return pPerl->PL_piSock->Bind(s, addr, namelen, ErrorNo());
  992. }
  993.  
  994. int _win32_listen (SOCKET s, int backlog)
  995. {
  996.     return pPerl->PL_piSock->Listen(s, backlog, ErrorNo());
  997. }
  998.  
  999. SOCKET _win32_accept (SOCKET s, struct sockaddr *addr, int *addrlen)
  1000. {
  1001.     return pPerl->PL_piSock->Accept(s, addr, addrlen, ErrorNo());
  1002. }
  1003.  
  1004. int _win32_connect (SOCKET s, const struct sockaddr *name, int namelen)
  1005. {
  1006.     return pPerl->PL_piSock->Connect(s, name, namelen, ErrorNo());
  1007. }
  1008.  
  1009. int _win32_send (SOCKET s, const char * buf, int len, int flags)
  1010. {
  1011.     return pPerl->PL_piSock->Send(s, buf, len, flags, ErrorNo());
  1012. }
  1013.  
  1014. int _win32_sendto (SOCKET s, const char * buf, int len, int flags,
  1015.                        const struct sockaddr *to, int tolen)
  1016. {
  1017.     return pPerl->PL_piSock->Sendto(s, buf, len, flags, to, tolen, ErrorNo());
  1018. }
  1019.  
  1020. int _win32_recv (SOCKET s, char * buf, int len, int flags)
  1021. {
  1022.     return pPerl->PL_piSock->Recv(s, buf, len, flags, ErrorNo());
  1023. }
  1024.  
  1025. int _win32_recvfrom (SOCKET s, char * buf, int len, int flags,
  1026.                          struct sockaddr *from, int * fromlen)
  1027. {
  1028.     return pPerl->PL_piSock->Recvfrom(s, buf, len, flags, from, fromlen, ErrorNo());
  1029. }
  1030.  
  1031. int _win32_shutdown (SOCKET s, int how)
  1032. {
  1033.     return pPerl->PL_piSock->Shutdown(s, how, ErrorNo());
  1034. }
  1035.  
  1036. int _win32_closesocket (SOCKET s)
  1037. {
  1038.     return pPerl->PL_piSock->Closesocket(s, ErrorNo());
  1039. }
  1040.  
  1041. int _win32_ioctlsocket (SOCKET s, long cmd, u_long *argp)
  1042. {
  1043.     return pPerl->PL_piSock->Ioctlsocket(s, cmd, argp, ErrorNo());
  1044. }
  1045.  
  1046. int _win32_setsockopt (SOCKET s, int level, int optname,
  1047.                            const char * optval, int optlen)
  1048. {
  1049.     return pPerl->PL_piSock->Setsockopt(s, level, optname, optval, optlen, ErrorNo());
  1050. }
  1051.  
  1052. int _win32_getsockopt (SOCKET s, int level, int optname, char * optval, int *optlen)
  1053. {
  1054.     return pPerl->PL_piSock->Getsockopt(s, level, optname, optval, optlen, ErrorNo());
  1055. }
  1056.  
  1057. int _win32_getpeername (SOCKET s, struct sockaddr *name, int * namelen)
  1058. {
  1059.     return pPerl->PL_piSock->Getpeername(s, name, namelen, ErrorNo());
  1060. }
  1061.  
  1062. int _win32_getsockname (SOCKET s, struct sockaddr *name, int * namelen)
  1063. {
  1064.     return pPerl->PL_piSock->Getsockname(s, name, namelen, ErrorNo());
  1065. }
  1066.  
  1067. int _win32_gethostname (char * name, int namelen)
  1068. {
  1069.     return pPerl->PL_piSock->Gethostname(name, namelen, ErrorNo());
  1070. }
  1071.  
  1072. struct hostent * _win32_gethostbyname(const char * name)
  1073. {
  1074.     return pPerl->PL_piSock->Gethostbyname(name, ErrorNo());
  1075. }
  1076.  
  1077. struct hostent * _win32_gethostbyaddr(const char * addr, int len, int type)
  1078. {
  1079.     return pPerl->PL_piSock->Gethostbyaddr(addr, len, type, ErrorNo());
  1080. }
  1081.  
  1082. struct protoent * _win32_getprotobyname(const char * name)
  1083. {
  1084.     return pPerl->PL_piSock->Getprotobyname(name, ErrorNo());
  1085. }
  1086.  
  1087. struct protoent * _win32_getprotobynumber(int proto)
  1088. {
  1089.     return pPerl->PL_piSock->Getprotobynumber(proto, ErrorNo());
  1090. }
  1091.  
  1092. struct servent * _win32_getservbyname(const char * name, const char * proto)
  1093. {
  1094.     return pPerl->PL_piSock->Getservbyname(name, proto, ErrorNo());
  1095. }
  1096.  
  1097. struct servent * _win32_getservbyport(int port, const char * proto)
  1098. {
  1099.     return pPerl->PL_piSock->Getservbyport(port, proto, ErrorNo());
  1100. }
  1101.  
  1102. int _win32_select (int nfds, Perl_fd_set *rfds, Perl_fd_set *wfds, Perl_fd_set *xfds,
  1103.           const struct timeval *timeout)
  1104. {
  1105.     return pPerl->PL_piSock->Select(nfds, (char*)rfds, (char*)wfds, (char*)xfds, timeout, ErrorNo());
  1106. }
  1107.  
  1108. void _win32_endnetent(void)
  1109. {
  1110.     pPerl->PL_piSock->Endnetent(ErrorNo());
  1111. }
  1112.  
  1113. void _win32_endhostent(void)
  1114. {
  1115.     pPerl->PL_piSock->Endhostent(ErrorNo());
  1116. }
  1117.  
  1118. void _win32_endprotoent(void)
  1119. {
  1120.     pPerl->PL_piSock->Endprotoent(ErrorNo());
  1121. }
  1122.  
  1123. void _win32_endservent(void)
  1124. {
  1125.     pPerl->PL_piSock->Endservent(ErrorNo());
  1126. }
  1127.  
  1128. struct netent * _win32_getnetent(void)
  1129. {
  1130.     return pPerl->PL_piSock->Getnetent(ErrorNo());
  1131. }
  1132.  
  1133. struct netent * _win32_getnetbyname(char *name)
  1134. {
  1135.     return pPerl->PL_piSock->Getnetbyname(name, ErrorNo());
  1136. }
  1137.  
  1138. struct netent * _win32_getnetbyaddr(long net, int type)
  1139. {
  1140.     return pPerl->PL_piSock->Getnetbyaddr(net, type, ErrorNo());
  1141. }
  1142.  
  1143. struct protoent *_win32_getprotoent(void)
  1144. {
  1145.     return pPerl->PL_piSock->Getprotoent(ErrorNo());
  1146. }
  1147.  
  1148. struct servent *_win32_getservent(void)
  1149. {
  1150.     return pPerl->PL_piSock->Getservent(ErrorNo());
  1151. }
  1152.  
  1153. void _win32_sethostent(int stayopen)
  1154. {
  1155.     pPerl->PL_piSock->Sethostent(stayopen, ErrorNo());
  1156. }
  1157.  
  1158. void _win32_setnetent(int stayopen)
  1159. {
  1160.     pPerl->PL_piSock->Setnetent(stayopen, ErrorNo());
  1161. }
  1162.  
  1163. void _win32_setprotoent(int stayopen)
  1164. {
  1165.     pPerl->PL_piSock->Setprotoent(stayopen, ErrorNo());
  1166. }
  1167.  
  1168. void _win32_setservent(int stayopen)
  1169. {
  1170.     pPerl->PL_piSock->Setservent(stayopen, ErrorNo());
  1171. }
  1172. } /* extern "C" */
  1173. EOCODE
  1174.  
  1175.  
  1176. print HDRFILE <<EOCODE;
  1177. #undef Perl_op_desc
  1178. char ** _Perl_op_desc ();
  1179. #define Perl_op_desc (_Perl_op_desc())
  1180.  
  1181. #undef Perl_op_name
  1182. char ** _Perl_op_name ();
  1183. #define Perl_op_name (_Perl_op_name())
  1184.  
  1185. #undef Perl_no_modify
  1186. char * _Perl_no_modify ();
  1187. #define Perl_no_modify (_Perl_no_modify())
  1188.  
  1189. #undef Perl_opargs
  1190. U32 * _Perl_opargs ();
  1191. #define Perl_opargs (_Perl_opargs())
  1192.  
  1193.  
  1194. #undef win32_errno
  1195. #undef win32_stdin
  1196. #undef win32_stdout
  1197. #undef win32_stderr
  1198. #undef win32_ferror
  1199. #undef win32_feof
  1200. #undef win32_fprintf
  1201. #undef win32_printf
  1202. #undef win32_vfprintf
  1203. #undef win32_vprintf
  1204. #undef win32_fread
  1205. #undef win32_fwrite
  1206. #undef win32_fopen
  1207. #undef win32_fdopen
  1208. #undef win32_freopen
  1209. #undef win32_fclose
  1210. #undef win32_fputs
  1211. #undef win32_fputc
  1212. #undef win32_ungetc
  1213. #undef win32_getc
  1214. #undef win32_fileno
  1215. #undef win32_clearerr
  1216. #undef win32_fflush
  1217. #undef win32_ftell
  1218. #undef win32_fseek
  1219. #undef win32_fgetpos
  1220. #undef win32_fsetpos
  1221. #undef win32_rewind
  1222. #undef win32_tmpfile
  1223. #undef win32_abort
  1224. #undef win32_fstat
  1225. #undef win32_stat
  1226. #undef win32_pipe
  1227. #undef win32_popen
  1228. #undef win32_pclose
  1229. #undef win32_rename
  1230. #undef win32_setmode
  1231. #undef win32_lseek
  1232. #undef win32_tell
  1233. #undef win32_dup
  1234. #undef win32_dup2
  1235. #undef win32_open
  1236. #undef win32_close
  1237. #undef win32_eof
  1238. #undef win32_read
  1239. #undef win32_write
  1240. #undef win32_mkdir
  1241. #undef win32_rmdir
  1242. #undef win32_chdir
  1243. #undef win32_setbuf
  1244. #undef win32_setvbuf
  1245. #undef win32_fgetc
  1246. #undef win32_fgets
  1247. #undef win32_gets
  1248. #undef win32_putc
  1249. #undef win32_puts
  1250. #undef win32_getchar
  1251. #undef win32_putchar
  1252. #undef win32_malloc
  1253. #undef win32_calloc
  1254. #undef win32_realloc
  1255. #undef win32_free
  1256. #undef win32_sleep
  1257. #undef win32_times
  1258. #undef win32_stat
  1259. #undef win32_ioctl
  1260. #undef win32_utime
  1261. #undef win32_getenv
  1262.  
  1263. #undef win32_htonl
  1264. #undef win32_htons
  1265. #undef win32_ntohl
  1266. #undef win32_ntohs
  1267. #undef win32_inet_addr
  1268. #undef win32_inet_ntoa
  1269.  
  1270. #undef win32_socket
  1271. #undef win32_bind
  1272. #undef win32_listen
  1273. #undef win32_accept
  1274. #undef win32_connect
  1275. #undef win32_send
  1276. #undef win32_sendto
  1277. #undef win32_recv
  1278. #undef win32_recvfrom
  1279. #undef win32_shutdown
  1280. #undef win32_closesocket
  1281. #undef win32_ioctlsocket
  1282. #undef win32_setsockopt
  1283. #undef win32_getsockopt
  1284. #undef win32_getpeername
  1285. #undef win32_getsockname
  1286. #undef win32_gethostname
  1287. #undef win32_gethostbyname
  1288. #undef win32_gethostbyaddr
  1289. #undef win32_getprotobyname
  1290. #undef win32_getprotobynumber
  1291. #undef win32_getservbyname
  1292. #undef win32_getservbyport
  1293. #undef win32_select
  1294. #undef win32_endhostent
  1295. #undef win32_endnetent
  1296. #undef win32_endprotoent
  1297. #undef win32_endservent
  1298. #undef win32_getnetent
  1299. #undef win32_getnetbyname
  1300. #undef win32_getnetbyaddr
  1301. #undef win32_getprotoent
  1302. #undef win32_getservent
  1303. #undef win32_sethostent
  1304. #undef win32_setnetent
  1305. #undef win32_setprotoent
  1306. #undef win32_setservent
  1307.  
  1308. #define win32_errno    _win32_errno
  1309. #define win32_stdin    _win32_stdin
  1310. #define win32_stdout   _win32_stdout
  1311. #define win32_stderr   _win32_stderr
  1312. #define win32_ferror   _win32_ferror
  1313. #define win32_feof     _win32_feof
  1314. #define win32_strerror _win32_strerror
  1315. #define win32_perror   _win32_perror
  1316. #define win32_fprintf  _win32_fprintf
  1317. #define win32_printf   _win32_printf
  1318. #define win32_vfprintf _win32_vfprintf
  1319. #define win32_vprintf  _win32_vprintf
  1320. #define win32_fread    _win32_fread
  1321. #define win32_fwrite   _win32_fwrite
  1322. #define win32_fopen    _win32_fopen
  1323. #define win32_fdopen   _win32_fdopen
  1324. #define win32_freopen  _win32_freopen
  1325. #define win32_fclose   _win32_fclose
  1326. #define win32_fputs    _win32_fputs
  1327. #define win32_fputc    _win32_fputc
  1328. #define win32_ungetc   _win32_ungetc
  1329. #define win32_getc     _win32_getc
  1330. #define win32_fileno   _win32_fileno
  1331. #define win32_clearerr _win32_clearerr
  1332. #define win32_fflush   _win32_fflush
  1333. #define win32_ftell    _win32_ftell
  1334. #define win32_fseek    _win32_fseek
  1335. #define win32_fgetpos  _win32_fgetpos
  1336. #define win32_fsetpos  _win32_fsetpos
  1337. #define win32_rewind   _win32_rewind
  1338. #define win32_tmpfile  _win32_tmpfile
  1339. #define win32_abort    _win32_abort
  1340. #define win32_fstat    _win32_fstat
  1341. #define win32_stat     _win32_stat
  1342. #define win32_pipe     _win32_pipe
  1343. #define win32_popen    _win32_popen
  1344. #define win32_pclose   _win32_pclose
  1345. #define win32_rename   _win32_rename
  1346. #define win32_setmode  _win32_setmode
  1347. #define win32_lseek    _win32_lseek
  1348. #define win32_tell     _win32_tell
  1349. #define win32_dup      _win32_dup
  1350. #define win32_dup2     _win32_dup2
  1351. #define win32_open     _win32_open
  1352. #define win32_close    _win32_close
  1353. #define win32_eof      _win32_eof
  1354. #define win32_read     _win32_read
  1355. #define win32_write    _win32_write
  1356. #define win32_mkdir    _win32_mkdir
  1357. #define win32_rmdir    _win32_rmdir
  1358. #define win32_chdir    _win32_chdir
  1359. #define win32_setbuf   _win32_setbuf
  1360. #define win32_setvbuf  _win32_setvbuf
  1361. #define win32_fgetc    _win32_fgetc
  1362. #define win32_fgets    _win32_fgets
  1363. #define win32_gets     _win32_gets
  1364. #define win32_putc     _win32_putc
  1365. #define win32_puts     _win32_puts
  1366. #define win32_getchar  _win32_getchar
  1367. #define win32_putchar  _win32_putchar
  1368. #define win32_malloc   _win32_malloc
  1369. #define win32_calloc   _win32_calloc
  1370. #define win32_realloc  _win32_realloc
  1371. #define win32_free     _win32_free
  1372. #define win32_sleep    _win32_sleep
  1373. #define win32_spawnvp  _win32_spawnvp
  1374. #define win32_times    _win32_times
  1375. #define win32_stat     _win32_stat
  1376. #define win32_ioctl    _win32_ioctl
  1377. #define win32_utime    _win32_utime
  1378. #define win32_getenv   _win32_getenv
  1379. #define win32_open_osfhandle _win32_open_osfhandle
  1380. #define win32_get_osfhandle  _win32_get_osfhandle
  1381.  
  1382. #define win32_htonl              _win32_htonl
  1383. #define win32_htons              _win32_htons
  1384. #define win32_ntohl              _win32_ntohl
  1385. #define win32_ntohs              _win32_ntohs
  1386. #define win32_inet_addr          _win32_inet_addr
  1387. #define win32_inet_ntoa          _win32_inet_ntoa
  1388.  
  1389. #define win32_socket             _win32_socket
  1390. #define win32_bind               _win32_bind
  1391. #define win32_listen             _win32_listen
  1392. #define win32_accept             _win32_accept
  1393. #define win32_connect            _win32_connect
  1394. #define win32_send               _win32_send
  1395. #define win32_sendto             _win32_sendto
  1396. #define win32_recv               _win32_recv
  1397. #define win32_recvfrom           _win32_recvfrom
  1398. #define win32_shutdown           _win32_shutdown
  1399. #define win32_closesocket        _win32_closesocket
  1400. #define win32_ioctlsocket        _win32_ioctlsocket
  1401. #define win32_setsockopt         _win32_setsockopt
  1402. #define win32_getsockopt         _win32_getsockopt
  1403. #define win32_getpeername        _win32_getpeername
  1404. #define win32_getsockname        _win32_getsockname
  1405. #define win32_gethostname        _win32_gethostname
  1406. #define win32_gethostbyname      _win32_gethostbyname
  1407. #define win32_gethostbyaddr      _win32_gethostbyaddr
  1408. #define win32_getprotobyname     _win32_getprotobyname
  1409. #define win32_getprotobynumber   _win32_getprotobynumber
  1410. #define win32_getservbyname      _win32_getservbyname
  1411. #define win32_getservbyport      _win32_getservbyport
  1412. #define win32_select             _win32_select
  1413. #define win32_endhostent         _win32_endhostent
  1414. #define win32_endnetent          _win32_endnetent
  1415. #define win32_endprotoent        _win32_endprotoent
  1416. #define win32_endservent         _win32_endservent
  1417. #define win32_getnetent          _win32_getnetent
  1418. #define win32_getnetbyname       _win32_getnetbyname
  1419. #define win32_getnetbyaddr       _win32_getnetbyaddr
  1420. #define win32_getprotoent        _win32_getprotoent
  1421. #define win32_getservent         _win32_getservent
  1422. #define win32_sethostent         _win32_sethostent
  1423. #define win32_setnetent          _win32_setnetent
  1424. #define win32_setprotoent        _win32_setprotoent
  1425. #define win32_setservent         _win32_setservent
  1426.  
  1427. int *     _win32_errno(void);
  1428. FILE*    _win32_stdin(void);
  1429. FILE*    _win32_stdout(void);
  1430. FILE*    _win32_stderr(void);
  1431. int    _win32_ferror(FILE *fp);
  1432. int    _win32_feof(FILE *fp);
  1433. char*    _win32_strerror(int e);
  1434. void    _win32_perror(const char *str);
  1435. int    _win32_fprintf(FILE *pf, const char *format, ...);
  1436. int    _win32_printf(const char *format, ...);
  1437. int    _win32_vfprintf(FILE *pf, const char *format, va_list arg);
  1438. int    _win32_vprintf(const char *format, va_list arg);
  1439. size_t    _win32_fread(void *buf, size_t size, size_t count, FILE *pf);
  1440. size_t    _win32_fwrite(const void *buf, size_t size, size_t count, FILE *pf);
  1441. FILE*    _win32_fopen(const char *path, const char *mode);
  1442. FILE*    _win32_fdopen(int fh, const char *mode);
  1443. FILE*    _win32_freopen(const char *path, const char *mode, FILE *pf);
  1444. int    _win32_fclose(FILE *pf);
  1445. int    _win32_fputs(const char *s,FILE *pf);
  1446. int    _win32_fputc(int c,FILE *pf);
  1447. int    _win32_ungetc(int c,FILE *pf);
  1448. int    _win32_getc(FILE *pf);
  1449. int    _win32_fileno(FILE *pf);
  1450. void    _win32_clearerr(FILE *pf);
  1451. int    _win32_fflush(FILE *pf);
  1452. long    _win32_ftell(FILE *pf);
  1453. int    _win32_fseek(FILE *pf,long offset,int origin);
  1454. int    _win32_fgetpos(FILE *pf,fpos_t *p);
  1455. int    _win32_fsetpos(FILE *pf,const fpos_t *p);
  1456. void    _win32_rewind(FILE *pf);
  1457. FILE*    _win32_tmpfile(void);
  1458. void    _win32_abort(void);
  1459. int      _win32_fstat(int fd,struct stat *sbufptr);
  1460. int      _win32_stat(const char *name,struct stat *sbufptr);
  1461. int    _win32_pipe( int *phandles, unsigned int psize, int textmode );
  1462. FILE*    _win32_popen( const char *command, const char *mode );
  1463. int    _win32_pclose( FILE *pf);
  1464. int    _win32_rename( const char *oldname, const char *newname);
  1465. int    _win32_setmode( int fd, int mode);
  1466. long    _win32_lseek( int fd, long offset, int origin);
  1467. long    _win32_tell( int fd);
  1468. int    _win32_dup( int fd);
  1469. int    _win32_dup2(int h1, int h2);
  1470. int    _win32_open(const char *path, int oflag,...);
  1471. int    _win32_close(int fd);
  1472. int    _win32_eof(int fd);
  1473. int    _win32_read(int fd, void *buf, unsigned int cnt);
  1474. int    _win32_write(int fd, const void *buf, unsigned int cnt);
  1475. int    _win32_mkdir(const char *dir, int mode);
  1476. int    _win32_rmdir(const char *dir);
  1477. int    _win32_chdir(const char *dir);
  1478. void    _win32_setbuf(FILE *pf, char *buf);
  1479. int    _win32_setvbuf(FILE *pf, char *buf, int type, size_t size);
  1480. char*    _win32_fgets(char *s, int n, FILE *pf);
  1481. char*    _win32_gets(char *s);
  1482. int    _win32_fgetc(FILE *pf);
  1483. int    _win32_putc(int c, FILE *pf);
  1484. int    _win32_puts(const char *s);
  1485. int    _win32_getchar(void);
  1486. int    _win32_putchar(int c);
  1487. void*    _win32_malloc(size_t size);
  1488. void*    _win32_calloc(size_t numitems, size_t size);
  1489. void*    _win32_realloc(void *block, size_t size);
  1490. void    _win32_free(void *block);
  1491. unsigned _win32_sleep(unsigned int);
  1492. int    _win32_spawnvp(int mode, const char *cmdname, const char *const *argv);
  1493. int    _win32_times(struct tms *timebuf);
  1494. int    _win32_stat(const char *path, struct stat *buf);
  1495. int    _win32_ioctl(int i, unsigned int u, char *data);
  1496. int    _win32_utime(const char *f, struct utimbuf *t);
  1497. char*   _win32_getenv(const char *name);
  1498. int     _win32_open_osfhandle(long handle, int flags);
  1499. long    _win32_get_osfhandle(int fd);
  1500.  
  1501. u_long _win32_htonl (u_long hostlong);
  1502. u_short _win32_htons (u_short hostshort);
  1503. u_long _win32_ntohl (u_long netlong);
  1504. u_short _win32_ntohs (u_short netshort);
  1505. unsigned long _win32_inet_addr (const char * cp);
  1506. char * _win32_inet_ntoa (struct in_addr in);
  1507.  
  1508. SOCKET _win32_socket (int af, int type, int protocol);
  1509. int _win32_bind (SOCKET s, const struct sockaddr *addr, int namelen);
  1510. int _win32_listen (SOCKET s, int backlog);
  1511. SOCKET _win32_accept (SOCKET s, struct sockaddr *addr, int *addrlen);
  1512. int _win32_connect (SOCKET s, const struct sockaddr *name, int namelen);
  1513. int _win32_send (SOCKET s, const char * buf, int len, int flags);
  1514. int _win32_sendto (SOCKET s, const char * buf, int len, int flags,
  1515.                        const struct sockaddr *to, int tolen);
  1516. int _win32_recv (SOCKET s, char * buf, int len, int flags);
  1517. int _win32_recvfrom (SOCKET s, char * buf, int len, int flags,
  1518.                          struct sockaddr *from, int * fromlen);
  1519. int _win32_shutdown (SOCKET s, int how);
  1520. int _win32_closesocket (SOCKET s);
  1521. int _win32_ioctlsocket (SOCKET s, long cmd, u_long *argp);
  1522. int _win32_setsockopt (SOCKET s, int level, int optname,
  1523.                            const char * optval, int optlen);
  1524. int _win32_getsockopt (SOCKET s, int level, int optname, char * optval, int *optlen);
  1525. int _win32_getpeername (SOCKET s, struct sockaddr *name, int * namelen);
  1526. int _win32_getsockname (SOCKET s, struct sockaddr *name, int * namelen);
  1527. int _win32_gethostname (char * name, int namelen);
  1528. struct hostent * _win32_gethostbyname(const char * name);
  1529. struct hostent * _win32_gethostbyaddr(const char * addr, int len, int type);
  1530. struct protoent * _win32_getprotobyname(const char * name);
  1531. struct protoent * _win32_getprotobynumber(int proto);
  1532. struct servent * _win32_getservbyname(const char * name, const char * proto);
  1533. struct servent * _win32_getservbyport(int port, const char * proto);
  1534. int _win32_select (int nfds, Perl_fd_set *rfds, Perl_fd_set *wfds, Perl_fd_set *xfds,
  1535.           const struct timeval *timeout);
  1536. void _win32_endnetent(void);
  1537. void _win32_endhostent(void);
  1538. void _win32_endprotoent(void);
  1539. void _win32_endservent(void);
  1540. struct netent * _win32_getnetent(void);
  1541. struct netent * _win32_getnetbyname(char *name);
  1542. struct netent * _win32_getnetbyaddr(long net, int type);
  1543. struct protoent *_win32_getprotoent(void);
  1544. struct servent *_win32_getservent(void);
  1545. void _win32_sethostent(int stayopen);
  1546. void _win32_setnetent(int stayopen);
  1547. void _win32_setprotoent(int stayopen);
  1548. void _win32_setservent(int stayopen);
  1549.  
  1550. #pragma warning(once : 4113)
  1551. EOCODE
  1552.  
  1553.  
  1554. close HDRFILE;
  1555. close OUTFILE;
  1556.